JavaScript ನಲ್ಲಿ ಡೇಟಾ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಆಳವಾದ ಅಧ್ಯಯನ. ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳ ಸೊಗಸಾದ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಸ್ಟಂ ಓವರ್‌ಲೋಡ್‌ಗಳು ಮತ್ತು ಮೆಮೊರಿ ಸೋರಿಕೆಗಳನ್ನು ಹೇಗೆ ತಡೆಯುವುದು ಎಂದು ತಿಳಿಯಿರಿ.
JavaScript Async Generator Backpressure: ಸ್ಟ್ರೀಮ್ ಫ್ಲೋ ನಿಯಂತ್ರಣಕ್ಕಾಗಿ ಅಂತಿಮ ಮಾರ್ಗದರ್ಶಿ
ಡೇಟಾ-ಇಂಟೆನ್ಸಿವ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಜಗತ್ತಿನಲ್ಲಿ, ನಾವು ಆಗಾಗ್ಗೆ ಒಂದು ಶಾಸ್ತ್ರೀಯ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸುತ್ತೇವೆ: ಒಬ್ಬ ಗ್ರಾಹಕರು ಪ್ರೊಸೆಸ್ ಮಾಡುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿ ಮಾಹಿತಿಯನ್ನು ಉತ್ಪಾದಿಸುವ ವೇಗದ ಡೇಟಾ ಮೂಲ. ಗಾರ್ಡನ್ ಸ್ಪ್ರಿಂಕ್ಲರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲಾದ ಫೈರ್‌ಹೋಸ್ ಅನ್ನು ಊಹಿಸಿಕೊಳ್ಳಿ. ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸಲು ಕವಾಟವಿಲ್ಲದೆ, ನಿಮಗೆ ಪ್ರವಾಹದ ಗೊಂದಲ ಉಂಟಾಗುತ್ತದೆ. ಸಾಫ್ಟ್‌ವೇರ್‌ನಲ್ಲಿ, ಈ ಪ್ರವಾಹವು ಅತಿಯಾದ ಮೆಮೊರಿ, ಸ್ಪಂದಿಸದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ಅಂತಿಮ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಈ ಮೂಲಭೂತ ಸವಾಲನ್ನು ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎಂಬ ಪರಿಕಲ್ಪನೆಯಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಆಧುನಿಕ JavaScript ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು: ಒಂದು ವಿಶಿಷ್ಟವಾದ ಸೊಗಸಾದ ಪರಿಹಾರವನ್ನು ನೀಡುತ್ತದೆ.
ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು JavaScript ನಲ್ಲಿ ಸ್ಟ್ರೀಮ್ ಪ್ರೊಸೆಸಿಂಗ್ ಮತ್ತು ಫ್ಲೋ ನಿಯಂತ್ರಣದ ಜಗತ್ತಿನಲ್ಲಿ ನಿಮಗೆ ಆಳವಾದ ಅಧ್ಯಯನವನ್ನು ನೀಡುತ್ತದೆ. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎಂದರೇನು, ದೃಢವಾದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಇದು ಏಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಅದನ್ನು ನಿರ್ವಹಿಸಲು ಅಂತರ್ಬೋಧೆಯ, ಅಂತರ್ನಿರ್ಮಿತ ಕಾರ್ಯವಿಧಾನವನ್ನು ಹೇಗೆ ಒದಗಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ನೀವು ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡುತ್ತಿರಲಿ, ನೈಜ-ಸಮಯದ API ಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತಿರಲಿ, ಅಥವಾ ಸಂಕೀರ್ಣ ಡೇಟಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುತ್ತಿರಲಿ, ಈ ಮಾದರಿಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನೀವು ಅಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ ಬರೆಯುವ ವಿಧಾನವನ್ನು ಮೂಲತಃ ಬದಲಾಯಿಸುತ್ತದೆ.
1. ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳ ವಿಘಟನೆ
ನಾವು ಪರಿಹಾರವನ್ನು ನಿರ್ಮಿಸುವ ಮೊದಲು, ನಾವು ಮೊದಲು ಒಗಟಿನ ಮೂಲಭೂತ ತುಣುಕುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಪ್ರಮುಖ ಪದಗಳನ್ನು ಸ್ಪಷ್ಟಪಡಿಸೋಣ: ಸ್ಟ್ರೀಮ್‌ಗಳು, ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಮತ್ತು ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳ ಮ್ಯಾಜಿಕ್.
ಸ್ಟ್ರೀಮ್ ಎಂದರೇನು?
ಸ್ಟ್ರೀಮ್ ಡೇಟಾದ ತುಂಡಲ್ಲ; ಅದು ಸಮಯದೊಂದಿಗೆ ಲಭ್ಯವಾಗುವ ಡೇಟಾದ ಅನುಕ್ರಮ. ಸಂಪೂರ್ಣ 10-ಗಿಗಾಬೈಟ್ ಫೈಲ್ ಅನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಮೆಮೊರಿಗೆ ಓದುವುದಕ್ಕಿಂತ (ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕ್ರಾಶ್ ಮಾಡಬಹುದು), ನೀವು ಅದನ್ನು ಸ್ಟ್ರೀಮ್ ಆಗಿ, ತುಂಡು ತುಂಡಾಗಿ ಓದಬಹುದು. ಈ ಪರಿಕಲ್ಪನೆಯು ಕಂಪ್ಯೂಟಿಂಗ್‌ನಲ್ಲಿ ಸಾರ್ವತ್ರಿಕವಾಗಿದೆ:
- ಫೈಲ್ I/O: ದೊಡ್ಡ ಲಾಗ್ ಫೈಲ್ ಅನ್ನು ಓದುವುದು ಅಥವಾ ವೀಡಿಯೊ ಡೇಟಾವನ್ನು ಬರೆಯುವುದು.
- ನೆಟ್‌ವರ್ಕಿಂಗ್: ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುವುದು, WebSocket ನಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವುದು ಅಥವಾ ವೀಡಿಯೊ ವಿಷಯವನ್ನು ಸ್ಟ್ರೀಮಿಂಗ್ ಮಾಡುವುದು.
- ಇಂಟರ್-ಪ್ರಾ large communication: ಒಂದು ಪ್ರೋಗ್ರಾಂನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಇನ್ನೊಂದರ ಇನ್‌ಪುಟ್‌ಗೆ ಪೈಪ್ ಮಾಡುವುದು.
ಕನಿಷ್ಠ ಮೆಮೊರಿ ಬಳಕೆಯೊಂದಿಗೆ ಹೆಚ್ಚಿನ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಲು ನಮ್ಮನ್ನು ಅನುಮತಿಸುವ ದಕ್ಷತೆಗಾಗಿ ಸ್ಟ್ರೀಮ್‌ಗಳು ಅತ್ಯಗತ್ಯ.
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎಂದರೇನು?
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎಂದರೆ ಡೇಟಾದ ಅಪೇಕ್ಷಿತ ಹರಿವನ್ನು ವಿರೋಧಿಸುವ ಪ್ರತಿರೋಧ ಅಥವಾ ಬಲ. ಇದು ನಿಧಾನ ಗ್ರಾಹಕರು ವೇಗದ ಉತ್ಪಾದಕರಿಗೆ, "ಹೇ, ನಿಧಾನಗೊಳಿಸು! ನಾನು ಅಪ್ ಟು ಡೇಟ್ ಆಗಿಲ್ಲ." ಎಂದು ಸಂಕೇತಿಸಲು ಅನುಮತಿಸುವ ಫೀಡ್‌ಬ್ಯಾಕ್ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ.
ಒಂದು ಶಾಸ್ತ್ರೀಯ ಹೋಲಿಕೆಯನ್ನು ಬಳಸೋಣ: ಒಂದು ಫ್ಯಾಕ್ಟರಿ ಅಸೆಂಬ್ಲಿ ಲೈನ್.
- ಉತ್ಪಾದಕ ಮೊದಲ ಸ್ಟೇಷನ್ ಆಗಿದೆ, ಹೆಚ್ಚಿನ ವೇಗದಲ್ಲಿ ಕನ್ವೇಯರ್ ಬೆಲ್ಟ್‌ನಲ್ಲಿ ಭಾಗಗಳನ್ನು ಇಡುತ್ತದೆ.
- ಗ್ರಾಹಕ ಅಂತಿಮ ಸ್ಟೇಷನ್ ಆಗಿದೆ, ಇದು ಪ್ರತಿ ಭಾಗದ ಮೇಲೆ ನಿಧಾನ, ವಿವರವಾದ ಜೋಡಣೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ.
ಉತ್ಪಾದಕ ತುಂಬಾ ವೇಗವಾಗಿದ್ದರೆ, ಭಾಗಗಳು ರಾಶಿಬೀಳುತ್ತವೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ ಗ್ರಾಹಕರನ್ನು ತಲುಪುವ ಮೊದಲು ಬೆಲ್ಟ್‌ನಿಂದ ಬೀಳುತ್ತವೆ. ಇದು ಡೇಟಾ ನಷ್ಟ ಮತ್ತು ಸಿಸ್ಟಂ ವೈಫಲ್ಯ. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಎಂದರೆ ಗ್ರಾಹಕರು ಲೈನ್‌ನ ಮೇಲಕ್ಕೆ ಕಳುಹಿಸುವ ಸಂಕೇತ, ಉತ್ಪಾದಕರಿಗೆ ಹಿಡಿತ ಸಾಧಿಸುವವರೆಗೆ ವಿರಾಮಗೊಳಿಸಲು ಹೇಳುತ್ತದೆ. ಇದು ಸಂಪೂರ್ಣ ವ್ಯವಸ್ಥೆಯು ಅದರ ನಿಧಾನವಾದ ಘಟಕದ ವೇಗದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಓವರ್‌ಲೋಡ್ ಅನ್ನು ತಡೆಯುತ್ತದೆ.
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಇಲ್ಲದೆ, ನೀವು ಅಪಾಯವನ್ನು ಎದುರಿಸುತ್ತೀರಿ:
- ಅನಿಯಂತ್ರಿತ ಬಫರಿಂಗ್: ಡೇಟಾ ಮೆಮೊರಿಯಲ್ಲಿ ರಾಶಿಬೀಳುತ್ತದೆ, ಇದು ಹೆಚ್ಚಿನ RAM ಬಳಕೆಗೆ ಮತ್ತು ಸಂಭವನೀಯ ಕ್ರ್ಯಾಶ್‌ಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
- ಡೇಟಾ ನಷ್ಟ: ಬಫರ್‌ಗಳು ಓವರ್‌ಫ್ಲೋ ಆದರೆ, ಡೇಟಾ ಕೈಬಿಡಬಹುದು.
- ಈವೆಂಟ್ ಲೂಪ್ ನಿರ್ಬಂಧಿಸುವುದು: Node.js ನಲ್ಲಿ, ಓವರ್‌ಲೋಡ್ ಆದ ವ್ಯವಸ್ಥೆಯು ಈವೆಂಟ್ ಲೂಪ್ ಅನ್ನು ನಿರ್ಬಂಧಿಸಬಹುದು, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸ್ಪಂದಿಸದಂತೆ ಮಾಡುತ್ತದೆ.
ಜನರೇಟರ್‌ಗಳು ಮತ್ತು ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳ ತ್ವರಿತ ಪುನರಾವರ್ತನೆ
ಆಧುನಿಕ JavaScript ನಲ್ಲಿ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್‌ಗೆ ಪರಿಹಾರವು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸಲು ಮತ್ತು ಪುನರಾರಂಭಿಸಲು ನಮಗೆ ಅನುಮತಿಸುವ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಇದೆ. ಅವುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸೋಣ.
ಜನರೇಟರ್‌ಗಳು (`function*`): ಇವು ವಿಶೇಷ ಕಾರ್ಯಗಳಾಗಿದ್ದು, ಅವುಗಳನ್ನು ನಿರ್ಗಮಿಸಬಹುದು ಮತ್ತು ನಂತರ ಮರುಪ್ರವೇಶಿಸಬಹುದು. ಅವು `yield` ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಮೌಲ್ಯವನ್ನು "ವಿರಾಮಗೊಳಿಸಲು" ಮತ್ತು ಹಿಂತಿರುಗಿಸಲು. ಕರೆ ಮಾಡುವವರು ನಂತರ ಮುಂದಿನ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಕಾರ್ಯದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಪುನರಾರಂಭಿಸಲು ನಿರ್ಧರಿಸಬಹುದು. ಇದು ಸಿಂಕ್ರೊನಸ್ ಡೇಟಾಗಾಗಿ ಆನ್-ಡಿಮ್ಯಾಂಡ್ ಪುಲ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುತ್ತದೆ.
ಅಸಿಂಕ್ ಇಟರೇಟರ್‌ಗಳು (`Symbol.asyncIterator`): ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಡೇಟಾ ಮೂಲಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಗೊಳ್ಳುವ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಒಂದು ಪ್ರೋಟೋಕಾಲ್ ಆಗಿದೆ. ಒಂದು ವಸ್ತುವನ್ನು `Symbol.asyncIterator` ಎಂಬ ಕೀ ಹೊಂದಿರುವ `next()` ಕಾರ್ಯವನ್ನು ಹಿಂತಿರುಗಿಸುವ ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಆಗಿದ್ದರೆ, ಅದು `{ value, done }` ಗೆ ರೆಸಲ್ಯೂಟ್ ಆಗುವ Promise ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು (`async function*`): ಇಲ್ಲಿ ಎಲ್ಲವೂ ಒಟ್ಟಿಗೆ ಬರುತ್ತದೆ. ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಜನರೇಟರ್‌ಗಳ ವಿರಾಮಗೊಳಿಸುವ ನಡವಳಿಕೆಯನ್ನು Promises ನ ಅಸಿಂಕ್ರೊನಸ್ ಸ್ವಭಾವದೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತವೆ. ಕಾಲಾನಂತರದಲ್ಲಿ ಬರುವ ಡೇಟಾದ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅವು ಪರಿಪೂರ್ಣ ಸಾಧನವಾಗಿವೆ.
ನೀವು `for await...of` ಲೂಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಸಿಂಕ್ ಜನರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತೀರಿ, ಇದು `.next()` ಅನ್ನು ಕರೆಯುವ ಸಂಕೀರ್ಣತೆಯನ್ನು ಮತ್ತು promises ರೆಸಲ್ಯೂಟ್ ಆಗುವವರೆಗೆ ಕಾಯುವುದನ್ನು ಅಬ್‌ಸ್ಟ್ರಾಕ್ಟ್ ಮಾಡುತ್ತದೆ.
async function* countToThree() {
yield 1; // Pause and yield 1
await new Promise(resolve => setTimeout(resolve, 1000)); // Asynchronously wait
yield 2; // Pause and yield 2
await new Promise(resolve => setTimeout(resolve, 1000));
yield 3; // Pause and yield 3
}
async function main() {
console.log("Starting consumption...");
for await (const number of countToThree()) {
console.log(number); // This will log 1, then 2 after 1s, then 3 after another 1s
}
console.log("Finished consumption.");
}
main();
ಪ್ರಮುಖ ಒಳನೋಟವೆಂದರೆ `for await...of` ಲೂಪ್ ಜನರೇಟರ್‌ನಿಂದ ಮೌಲ್ಯಗಳನ್ನು *ಪುಲ್* ಮಾಡುತ್ತದೆ. ಪ್ರಸ್ತುತ ಮೌಲ್ಯಕ್ಕಾಗಿ ಲೂಪ್ ಒಳಗಿನ ಕೋಡ್ ಮುಗಿಯುವವರೆಗೆ ಅದು ಮುಂದಿನ ಮೌಲ್ಯವನ್ನು ಕೇಳುವುದಿಲ್ಲ. ಈ ಅಂತರ್ಗತ ಪುಲ್-ಆಧಾರಿತ ಸ್ವಭಾವವು ಸ್ವಯಂಚಾಲಿತ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್‌ನ ರಹಸ್ಯವಾಗಿದೆ.
2. ಸಮಸ್ಯೆಯನ್ನು ಚಿತ್ರಿಸುವುದು: ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಇಲ್ಲದೆ ಸ್ಟ್ರೀಮಿಂಗ್
ಪರಿಹಾರವನ್ನು ನಿಜವಾಗಿಯೂ ಮೆಚ್ಚಿಕೊಳ್ಳಲು, ಒಂದು ಸಾಮಾನ್ಯ ಆದರೆ ದೋಷಪೂರಿತ ಮಾದರಿಯನ್ನು ನೋಡೋಣ. ನಾವು ತುಂಬಾ ವೇಗದ ಡೇಟಾ ಮೂಲ (ಉತ್ಪಾದಕ) ಮತ್ತು ನಿಧಾನ ಡೇಟಾ ಪ್ರೊಸೆಸರ್ (ಗ್ರಾಹಕ) ಹೊಂದಿದ್ದೇವೆ ಎಂದು imagine ಮಾಡೋಣ, ಬಹುಶಃ ನಿಧಾನ ಡೇಟಾಬೇಸ್‌ಗೆ ಬರೆಯುವ ಅಥವಾ ದರ-ಸೀಮಿತ API ಅನ್ನು ಕರೆಯುವ ಒಂದು.
ಇಲ್ಲಿ ಪುಶ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಯಾದ ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ಈವೆಂಟ್-ಎಮಿಟರ್ ಅಥವಾ ಕಾಲ್‌ಬ್ಯಾಕ್-ಶೈಲಿಯ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸಿಮ್ಯುಲೇಶನ್ ಇಲ್ಲಿದೆ.
// Represents a very fast data source
class FastProducer {
constructor() {
this.listeners = [];
}
onData(listener) {
this.listeners.push(listener);
}
start() {
let id = 0;
// Produce data every 10 milliseconds
this.interval = setInterval(() => {
const data = { id: id++, timestamp: Date.now() };
console.log(`PRODUCER: Emitting item ${data.id}`);
this.listeners.forEach(listener => listener(data));
}, 10);
}
stop() {
clearInterval(this.interval);
}
}
// Represents a slow consumer (e.g., writing to a slow network service)
async function slowConsumer(data) {
console.log(` CONSUMER: Starting to process item ${data.id}...`);
// Simulate a slow I/O operation taking 500 milliseconds
await new Promise(resolve => setTimeout(resolve, 500));
console.log(` CONSUMER: ...Finished processing item ${data.id}`);
}
// --- Let's run the simulation ---
const producer = new FastProducer();
const dataBuffer = [];
producer.onData(data => {
console.log(`Received item ${data.id}, adding to buffer.`);
dataBuffer.push(data);
// A naive attempt to process
// slowConsumer(data); // This would block new events if we awaited it
});
producer.start();
// Let's inspect the buffer after a short time
setTimeout(() => {
producer.stop();
console.log(`
--- After 2 seconds ---
`);
console.log(`Buffer size is: ${dataBuffer.length}`);
console.log(`Producer created around 200 items, but the consumer would have only processed 4.`);
console.log(`The other 196 items are sitting in memory, waiting.`);
}, 2000);
ಇಲ್ಲಿ ಏನಾಗುತ್ತಿದೆ?
ಉತ್ಪಾದಕ ಪ್ರತಿ 10ms ಗೆ ಡೇಟಾವನ್ನು ಹೊರಡಿಸುತ್ತಿದೆ. ಗ್ರಾಹಕರು ಒಂದು ಐಟಂ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಲು 500ms ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಉತ್ಪಾದಕ ಗ್ರಾಹಕರಿಗಿಂತ 50 ಪಟ್ಟು ವೇಗವಾಗಿದೆ!
ಈ ಪುಶ್-ಆಧಾರಿತ ಮಾದರಿಯಲ್ಲಿ, ಉತ್ಪಾದಕನು ಗ್ರಾಹಕರ ಸ್ಥಿತಿಯ ಬಗ್ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಅರಿಯುವುದಿಲ್ಲ. ಅದು ಡೇಟಾವನ್ನು ತಳ್ಳುತ್ತಲೇ ಇರುತ್ತದೆ. ನಮ್ಮ ಕೋಡ್ ಬರುವ ಡೇಟಾವನ್ನು `dataBuffer` ಎಂಬ ಅರೇಗೆ ಸೇರಿಸುತ್ತದೆ. ಕೇವಲ 2 ಸೆಕೆಂಡುಗಳಲ್ಲಿ, ಈ ಬಫರ್ ಸುಮಾರು 200 ಐಟಂಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಗಂಟೆಗಟ್ಟಲೆ ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಜವಾದ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ, ಈ ಬಫರ್ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಬೆಳೆಯುತ್ತದೆ, ಲಭ್ಯವಿರುವ ಎಲ್ಲಾ ಮೆಮೊರಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕ್ರಾಶ್ ಮಾಡುತ್ತದೆ. ಇದು ಅದರ ಅತ್ಯಂತ ಅಪಾಯಕಾರಿ ರೂಪದಲ್ಲಿ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸಮಸ್ಯೆಯಾಗಿದೆ.
3. ಪರಿಹಾರ: ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳೊಂದಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್
ಈಗ, ಅಸಿಂಕ್ ಜನರೇಟರ್ ಬಳಸಿಕೊಂಡು ಅದೇ ಸನ್ನಿವೇಶವನ್ನು ರಿಫ್ಯಾಕ್ಟರ್ ಮಾಡೋಣ. ನಾವು ಉತ್ಪಾದಕವನ್ನು "ಪುಶ್ ಮಾಡುವವರಿಂದ" "ಪುಲ್ ಮಾಡಬಹುದಾದ" ವಸ್ತುವಾಗಿ ಪರಿವರ್ತಿಸುತ್ತೇವೆ.
ಪ್ರಮುಖ ಕಲ್ಪನೆಯೆಂದರೆ ಡೇಟಾ ಮೂಲವನ್ನು `async function*` ನಲ್ಲಿ ಸುತ್ತುವರಿಯುವುದು. ನಂತರ ಗ್ರಾಹಕರು ಡೇಟಾ ಸಿದ್ಧವಾದಾಗ ಮಾತ್ರ ಅದನ್ನು ಪುಲ್ ಮಾಡಲು `for await...of` ಲೂಪ್ ಅನ್ನು ಬಳಸುತ್ತಾರೆ.
// PRODUCER: A data source wrapped in an async generator
async function* createFastProducer() {
let id = 0;
while (true) {
// Simulate a fast data source creating an item
await new Promise(resolve => setTimeout(resolve, 10));
const data = { id: id++, timestamp: Date.now() };
console.log(`PRODUCER: Yielding item ${data.id}`);
yield data; // Pause until the consumer requests the next item
}
}
// CONSUMER: A slow process, just like before
async function slowConsumer(data) {
console.log(` CONSUMER: Starting to process item ${data.id}...`);
// Simulate a slow I/O operation taking 500 milliseconds
await new Promise(resolve => setTimeout(resolve, 500));
console.log(` CONSUMER: ...Finished processing item ${data.id}`);
}
// --- The main execution logic ---
async function main() {
const producer = createFastProducer();
// The magic of `for await...of`
for await (const data of producer) {
await slowConsumer(data);
}
}
main();
ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಹರಿವನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ
ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ, ನೀವು ನಾಟಕೀಯವಾಗಿ ವಿಭಿನ್ನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ನೋಡುತ್ತೀರಿ. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
PRODUCER: Yielding item 0 CONSUMER: Starting to process item 0... CONSUMER: ...Finished processing item 0 PRODUCER: Yielding item 1 CONSUMER: Starting to process item 1... CONSUMER: ...Finished processing item 1 PRODUCER: Yielding item 2 CONSUMER: Starting to process item 2... ...
ಪರಿಪೂರ್ಣ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಗಮನಿಸಿ. ಗ್ರಾಹಕರು ಹಿಂದಿನದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರೊಸೆಸ್ ಮಾಡುವುದನ್ನು ಮುಗಿಸಿದ ನಂತರವಷ್ಟೇ ಉತ್ಪಾದಕರು ಹೊಸ ಐಟಂ ಅನ್ನು ನೀಡುತ್ತಾರೆ. ಬೆಳೆಯುತ್ತಿರುವ ಬಫರ್ ಮತ್ತು ಮೆಮೊರಿ ಸೋರಿಕೆ ಇಲ್ಲ. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ.
ಇದು ಏಕೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಹಂತ-ಹಂತದ ವಿವರ ಇಲ್ಲಿದೆ:
- `for await...of` ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಮೊದಲ ಐಟಂ ಅನ್ನು ವಿನಂತಿಸಲು ಹಿನ್ನೆಲೆಯಲ್ಲಿ `producer.next()` ಅನ್ನು ಕರೆಯುತ್ತದೆ.
- `createFastProducer` ಕಾರ್ಯ ಕಾರ್ಯಗತಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು 10ms ಕಾಯುತ್ತದೆ, ಐಟಂ 0 ಗಾಗಿ `data` ಅನ್ನು ರಚಿಸುತ್ತದೆ, ನಂತರ `yield data` ಗೆ ಬರುತ್ತದೆ.
- ಜನರೇಟರ್ ತನ್ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನೀಡಿದ ಮೌಲ್ಯದೊಂದಿಗೆ (`{ value: data, done: false }`) ರೆಸಲ್ಯೂಟ್ ಆಗುವ Promise ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
- `for await...of` ಲೂಪ್ ಮೌಲ್ಯವನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಈ ಮೊದಲ ಡೇಟಾ ಐಟಂನೊಂದಿಗೆ ಲೂಪ್ ಬಾಡಿ ಕಾರ್ಯಗತಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.
- ಇದು `await slowConsumer(data)` ಅನ್ನು ಕರೆಯುತ್ತದೆ. ಇದು ಪೂರ್ಣಗೊಳ್ಳಲು 500ms ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
- ಇದು ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಭಾಗ: `await slowConsumer(data)` promise ರೆಸಲ್ಯೂಟ್ ಆಗುವವರೆಗೆ `for await...of` ಲೂಪ್ `producer.next()` ಅನ್ನು ಮತ್ತೆ ಕರೆಯುವುದಿಲ್ಲ. ಉತ್ಪಾದಕರು ಅದರ `yield` ಹೇಳಿಕೆಯಲ್ಲಿ ವಿರಾಮಗೊಳಿಸುತ್ತಾರೆ.
- 500ms ನಂತರ, `slowConsumer` ಮುಗಿಯುತ್ತದೆ. ಈ ಪುನರಾವರ್ತನೆಗಾಗಿ ಲೂಪ್ ಬಾಡಿ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ.
- ಈಗ, ಮತ್ತು ಈಗ ಮಾತ್ರ, `for await...of` ಲೂಪ್ ಮುಂದಿನ ಐಟಂ ಅನ್ನು ವಿನಂತಿಸಲು `producer.next()` ಅನ್ನು ಮತ್ತೆ ಕರೆಯುತ್ತದೆ.
- `createFastProducer` ಕಾರ್ಯ ಅದು ಬಿಟ್ಟ ಸ್ಥಳದಿಂದ ಅನ್-ಪಾಸ್ ಆಗುತ್ತದೆ ಮತ್ತು ಐಟಂ 1 ಗಾಗಿ ಲೂಪ್ ಅನ್ನು ಪುನರಾರಂಭಿಸುತ್ತದೆ.
ಗ್ರಾಹಕರ ಸಂಸ್ಕರಣಾ ದರವು ಉತ್ಪಾದಕರ ಉತ್ಪಾದನಾ ದರವನ್ನು ನೇರವಾಗಿ ನಿಯಂತ್ರಿಸುತ್ತದೆ. ಇದು ಪುಲ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆ, ಮತ್ತು ಇದು ಆಧುನಿಕ JavaScript ನಲ್ಲಿ ಸೊಗಸಾದ ಫ್ಲೋ ನಿಯಂತ್ರಣದ ಅಡಿಪಾಯವಾಗಿದೆ.
4. ಸುಧಾರಿತ ಮಾದರಿಗಳು ಮತ್ತು ನೈಜ-ಜೀವನದ ಬಳಕೆ ಪ್ರಕರಣಗಳು
ಸಂಕೀರ್ಣ ಡೇಟಾ ರೂಪಾಂತರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ನೀವು ಅವುಗಳನ್ನು ಪೈಪ್‌ಲೈನ್‌ಗಳಾಗಿ ಸಂಯೋಜಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳ ನಿಜವಾದ ಶಕ್ತಿ ಹೊಳೆಯುತ್ತದೆ.
ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಪೈಪ್ ಮಾಡುವುದು ಮತ್ತು ರೂಪಾಂತರಿಸುವುದು
ನೀವು Unix ಕಮಾಂಡ್ ಲೈನ್‌ನಲ್ಲಿ ಕಮಾಂಡ್‌ಗಳನ್ನು ಪೈಪ್ ಮಾಡಬಹುದು (ಉದಾಹರಣೆಗೆ, `cat log.txt | grep 'ERROR' | wc -l`), ನೀವು ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳನ್ನು ಸರಪಳಿಸಬಹುದು. ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮರ್ ಎಂದರೆ ಇನ್ನೊಂದು ಅಸಿಂಕ್ ಇಟರೇಬಲ್ ಅನ್ನು ಅದರ ಇನ್‌ಪುಟ್ ಆಗಿ ಸ್ವೀಕರಿಸುವ ಮತ್ತು ರೂಪಾಂತರಗೊಂಡ ಡೇಟಾವನ್ನು ನೀಡುವ ಅಸಿಂಕ್ ಜನರೇಟರ್.
ಮಾರಾಟ ಡೇಟಾದ ದೊಡ್ಡ CSV ಫೈಲ್ ಅನ್ನು ನಾವು ಪ್ರೊಸೆಸ್ ಮಾಡುತ್ತಿದ್ದೇವೆ ಎಂದು ಊಹಿಸೋಣ. ನಾವು ಫೈಲ್ ಅನ್ನು ಓದಲು, ಪ್ರತಿ ಸಾಲನ್ನು ವಿಶ್ಲೇಷಿಸಲು, ಹೆಚ್ಚಿನ-ಮೌಲ್ಯದ ವಹಿವಾಟುಗಳನ್ನು ಫಿಲ್ಟರ್ ಮಾಡಲು, ಮತ್ತು ನಂತರ ಅವುಗಳನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ಉಳಿಸಲು ಬಯಸುತ್ತೇವೆ.
const fs = require('fs');
const { once } = require('events');
// PRODUCER: Reads a large file line by line
async function* readFileLines(filePath) {
const readable = fs.createReadStream(filePath, { encoding: 'utf8' });
let buffer = '';
readable.on('data', chunk => {
buffer += chunk;
let newlineIndex;
while ((newlineIndex = buffer.indexOf('\n')) >= 0) {
const line = buffer.slice(0, newlineIndex);
buffer = buffer.slice(newlineIndex + 1);
readable.pause(); // Explicitly pause Node.js stream for backpressure
yield line;
}
});
readable.on('end', () => {
if (buffer.length > 0) {
yield buffer; // Yield the last line if no trailing newline
}
});
// A simplified way to wait for the stream to finish or error
await once(readable, 'close');
}
// TRANSFORMER 1: Parses CSV lines into objects
async function* parseCSV(lines) {
for await (const line of lines) {
const [id, product, amount] = line.split(',');
if (id && product && amount) {
yield { id, product, amount: parseFloat(amount) };
}
}
}
// TRANSFORMER 2: Filters for high-value transactions
async function* filterHighValue(transactions, minValue) {
for await (const tx of transactions) {
if (tx.amount >= minValue) {
yield tx;
}
}
}
// CONSUMER: Saves the final data to a slow database
async function saveToDatabase(transaction) {
console.log(`Saving transaction ${transaction.id} with amount ${transaction.amount} to DB...`);
await new Promise(resolve => setTimeout(resolve, 100)); // Simulate slow DB write
}
// --- The Composed Pipeline ---
async function processSalesFile(filePath) {
const lines = readFileLines(filePath);
const transactions = parseCSV(lines);
const highValueTxs = filterHighValue(transactions, 1000);
console.log("Starting ETL pipeline...");
for await (const tx of highValueTxs) {
await saveToDatabase(tx);
}
console.log("Pipeline finished.");
}
// Create a dummy large CSV file for testing
// fs.writeFileSync('sales.csv', ...);
// processSalesFile('sales.csv');
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸರಣಿಯ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹರಡುತ್ತದೆ. `saveToDatabase` ನಿಧಾನವಾದ ಭಾಗವಾಗಿದೆ. ಅದರ `await` ಅಂತಿಮ `for await...of` ಲೂಪ್ ಅನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ. ಇದು `filterHighValue` ಅನ್ನು ವಿರಾಮಗೊಳಿಸುತ್ತದೆ, ಇದು `parseCSV` ನಿಂದ ಐಟಂಗಳನ್ನು ಕೇಳುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ, ಇದು `readFileLines` ನಿಂದ ಐಟಂಗಳನ್ನು ಕೇಳುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ, ಇದು ಅಂತಿಮವಾಗಿ Node.js ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಡಿಸ್ಕ್‌ನಿಂದ ಓದುವುದನ್ನು ವಿರಾಮಗೊಳಿಸಲು ಹೇಳುತ್ತದೆ. ಸಂಪೂರ್ಣ ವ್ಯವಸ್ಥೆಯು ಲಾಕ್-ಸ್ಟೆಪ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ, ಕನಿಷ್ಠ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತದೆ, ಅಸಿಂಕ್ ಇಟರೇಶನ್‌ನ ಸರಳ ಪುಲ್-ಯಾಂತ್ರಿಕದಿಂದ ಅ all ರ್ಗ್ಯಾನೈಸ್ ಆಗುತ್ತದೆ.
ಸಂಪನ್ಮೂಲ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆ `try...finally` ಜೊತೆಗೆ
ಗ್ರಾಹಕರು ಮುಂಚಿತವಾಗಿ ಸಂಸ್ಕರಣೆಯನ್ನು ನಿಲ್ಲಿಸಿದರೆ (ಉದಾಹರಣೆಗೆ, `break` ಹೇಳಿಕೆಯನ್ನು ಬಳಸಿ)? ಜನರೇಟರ್ ತೆರೆದ ಸಂಪನ್ಮೂಲಗಳಾದ ಫೈಲ್ ಹ್ಯಾಂಡಲ್‌ಗಳು ಅಥವಾ ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಗಳನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು. ಜನರೇಟರ್ ಒಳಗೆ `finally` ಬ್ಲಾಕ್ ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಗೆ ಪರಿಪೂರ್ಣ ಸ್ಥಳವಾಗಿದೆ.
`for await...of` ಲೂಪ್ ಅನ್ನು ಅಕಾಲಿಕವಾಗಿ ನಿರ್ಗಮಿಸಿದಾಗ (`break`, `return`, ಅಥವಾ ದೋಷದ ಮೂಲಕ), ಅದು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಜನರೇಟರ್‌ನ `.return()` ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತದೆ. ಇದು ಜನರೇಟರ್ ಅನ್ನು ಅದರ `finally` ಬ್ಲಾಕ್‌ಗೆ ಹೋಗುವಂತೆ ಮಾಡುತ್ತದೆ, ನೀವು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.
async function* fileReaderWithCleanup(filePath) {
let fileHandle;
try {
console.log("GENERATOR: Opening file...");
fileHandle = await fs.promises.open(filePath, 'r');
// ... logic to yield lines from the file ...
yield 'line 1';
yield 'line 2';
yield 'line 3';
} finally {
if (fileHandle) {
console.log("GENERATOR: Closing file handle.");
await fileHandle.close();
}
}
}
async function main() {
for await (const line of fileReaderWithCleanup('my-file.txt')) {
console.log("CONSUMER:", line);
if (line === 'line 2') {
console.log("CONSUMER: Breaking the loop early.");
break; // Exit the loop
}
}
}
main();
// Output:
// GENERATOR: Opening file...
// CONSUMER: line 1
// CONSUMER: line 2
// CONSUMER: Breaking the loop early.
// GENERATOR: Closing file handle.
5. ಇತರ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಕಾರ್ಯವಿಧಾನಗಳೊಂದಿಗೆ ಹೋಲಿಕೆ
JavaScript ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ನಿರ್ವಹಿಸಲು ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಏಕೈಕ ಮಾರ್ಗವಲ್ಲ. ಇತರ ಜನಪ್ರಿಯ ವಿಧಾನಗಳೊಂದಿಗೆ ಅವು ಹೇಗೆ ಹೋಲಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಹಾಯಕವಾಗಿದೆ.
Node.js ಸ್ಟ್ರೀಮ್‌ಗಳು (`.pipe()` ಮತ್ತು `pipeline`)
Node.js ಶಕ್ತಿಯುತ, ಅಂತರ್ನಿರ್ಮಿತ ಸ್ಟ್ರೀಮ್‌ಗಳ API ಹೊಂದಿದೆ, ಇದು ವರ್ಷಗಳಿಂದ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ನಿರ್ವಹಿಸಿದೆ. ನೀವು `readable.pipe(writable)` ಅನ್ನು ಬಳಸಿದಾಗ, Node.js ಆಂತರಿಕ ಬಫರ್‌ಗಳು ಮತ್ತು `highWaterMark` ಸೆಟ್ಟಿಂಗ್ ಆಧಾರದ ಮೇಲೆ ಡೇಟಾ ಹರಿವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಅಂತರ್ನಿರ್ಮಿತವಾಗಿ ಹೊಂದಿರುವ ಈವೆಂಟ್-ಆಧಾರಿತ, ಪುಶ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ.
- ಸಂಕೀರ್ಣತೆ: Node.js ಸ್ಟ್ರೀಮ್‌ಗಳ API ವಿಶೇಷವಾಗಿ ಕಸ್ಟಮ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಸ್ಟ್ರೀಮ್‌ಗಳಿಗೆ ಸರಿಯಾಗಿ ಅಳವಡಿಸಲು ಕುಖ್ಯಾತವಾಗಿ ಸಂಕೀರ್ಣವಾಗಿದೆ. ಇದು ಕ್ಲಾಸ್‌ಗಳನ್ನು ವಿಸ್ತರಿಸುವುದು ಮತ್ತು ಆಂತರಿಕ ಸ್ಥಿತಿ ಮತ್ತು ಈವೆಂಟ್‌ಗಳನ್ನು (`'data'`, `'end'`, `'drain'`) ನಿರ್ವಹಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.
- ದೋಷ ನಿರ್ವಹಣೆ: `.pipe()` ನೊಂದಿಗೆ ದೋಷ ನಿರ್ವಹಣೆ ಕಷ್ಟಕರವಾಗಿದೆ, ಏಕೆಂದರೆ ಒಂದು ಸ್ಟ್ರೀಮ್‌ನಲ್ಲಿನ ದೋಷವು ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿರುವ ಇತರರನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಾಶಮಾಡುವುದಿಲ್ಲ. ಅದಕ್ಕಾಗಿಯೇ `stream.pipeline` ಅನ್ನು ಹೆಚ್ಚು ದೃಢವಾದ ಪರ್ಯಾಯವಾಗಿ ಪರಿಚಯಿಸಲಾಯಿತು.
- ಓದುವಿಕೆ: ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ರೂಪಾಂತರಗಳಿಗಾಗಿ, ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಸಿಂಕ್ರೊನಸ್ ಆಗಿರುವ ಮತ್ತು ಓದಲು ಮತ್ತು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾದ ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತವೆ.
Node.js ನಲ್ಲಿ ಹೆಚ್ಚಿನ-ಕಾರ್ಯಕ್ಷಮತೆಯ, ಕಡಿಮೆ-ಮಟ್ಟದ I/O ಗಾಗಿ, ಸ್ಥಳೀಯ ಸ್ಟ್ರೀಮ್‌ಗಳ API ಇನ್ನೂ ಅತ್ಯುತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಅಪ್ಲಿಕೇಶನ್-ಮಟ್ಟದ ತರ್ಕ ಮತ್ತು ಡೇಟಾ ರೂಪಾಂತರಗಳಿಗಾಗಿ, ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಹೆಚ್ಚಾಗಿ ಸರಳ ಮತ್ತು ಸೊಗಸಾದ ಡೆವಲಪರ್ ಅನುಭವವನ್ನು ಒದಗಿಸುತ್ತವೆ.
ರಿಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ (RxJS)
RxJS ನಂತಹ ಲೈಬ್ರರಿಗಳು Observable ಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತವೆ. Node.js ಸ್ಟ್ರೀಮ್‌ಗಳಂತೆ, Observable ಗಳು ಪ್ರಾಥಮಿಕವಾಗಿ ಪುಶ್-ಆಧಾರಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಉತ್ಪಾದಕ (Observable) ಮೌಲ್ಯಗಳನ್ನು ಹೊರಸೂಸುತ್ತದೆ, ಮತ್ತು ಗ್ರಾಹಕ (Observer) ಅವುಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ. RxJS ನಲ್ಲಿ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿರುವುದಿಲ್ಲ; `buffer`, `throttle`, `debounce`, ಅಥವಾ ಕಸ್ಟಮ್ ಶೆಡ್ಯೂಲರ್‌ಗಳಂತಹ ವಿವಿಧ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಿರ್ವಹಿಸಬೇಕು.
- ಪ್ಯಾರಾಡಿಮ್: RxJS ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೊನಸ್ ಈವೆಂಟ್ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಶಕ್ತಿಯುತ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ಯಾರಾಡಿಮ್ ಅನ್ನು ನೀಡುತ್ತದೆ. UI ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್‌ನಂತಹ ಸನ್ನಿವೇಶಗಳಿಗೆ ಇದು ಅತ್ಯಂತ ಶಕ್ತಿಯುತವಾಗಿದೆ.
- ಕಲಿಯುವ ವಕ್ರತೆ: RxJS ಅದರ ವ್ಯಾಪಕವಾದ ಆಪರೇಟರ್‌ಗಳು ಮತ್ತು ರಿಯಾಕ್ಟಿವ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಚಿಂತನೆಯ ಬದಲಾವಣೆಯಿಂದಾಗಿ ಕಡಿದಾದ ಕಲಿಕೆಯ ವಕ್ರತೆಯನ್ನು ಹೊಂದಿದೆ.
- ಪುಲ್ ವಿರುದ್ಧ ಪುಶ್: ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವು ಉಳಿದಿದೆ. ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಮೂಲತಃ ಪುಲ್-ಆಧಾರಿತವಾಗಿವೆ (ಗ್ರಾಹಕನು ನಿಯಂತ್ರಣದಲ್ಲಿದ್ದಾನೆ), ಆದರೆ Observable ಗಳು ಪುಶ್-ಆಧಾರಿತವಾಗಿವೆ (ಉತ್ಪಾದಕನು ನಿಯಂತ್ರಣದಲ್ಲಿದ್ದಾನೆ, ಮತ್ತು ಗ್ರಾಹಕನು ಒತ್ತಡಕ್ಕೆ ಪ್ರತಿಕ್ರಿಯಿಸಬೇಕು).
ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಸ್ಥಳೀಯ ಭಾಷಾ ವೈಶಿಷ್ಟ್ಯವಾಗಿದ್ದು, ಅವುಗಳನ್ನು ಅನೇಕ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಸಮಸ್ಯೆಗಳಿಗೆ ಹಗುರವಾದ ಮತ್ತು ಅವಲಂಬನೆ-ಮುಕ್ತ ಆಯ್ಕೆಯನ್ನಾಗಿ ಮಾಡುತ್ತದೆ, ಇದು ಇಲ್ಲದಿದ್ದರೆ RxJS ನಂತಹ ಸಮಗ್ರ ಲೈಬ್ರರಿಯನ್ನು ಅಗತ್ಯಪಡಬಹುದು.
ತೀರ್ಮಾನ: ಪುಲ್ ಅನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಒಂದು ಐಚ್ಛಿಕ ವೈಶಿಷ್ಟ್ಯವಲ್ಲ; ಇದು ಸ್ಥಿರ, ಸ್ಕೇಲೆಬಲ್ ಮತ್ತು ಮೆಮೊರಿ-ದಕ್ಷ ಡೇಟಾ ಪ್ರೊಸೆಸಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮೂಲಭೂತ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು ಸಿಸ್ಟಂ ವೈಫಲ್ಯಕ್ಕೆ ಒಂದು ಪಾಕವಿಧಾನವಾಗಿದೆ.
ವರ್ಷಗಳವರೆಗೆ, JavaScript ಡೆವಲಪರ್‌ಗಳು ಸ್ಟ್ರೀಮ್ ಫ್ಲೋ ನಿಯಂತ್ರಣವನ್ನು ನಿರ್ವಹಿಸಲು ಸಂಕೀರ್ಣ, ಈವೆಂಟ್-ಆಧಾರಿತ API ಗಳು ಅಥವಾ ಮೂರನೇ ವ್ಯಕ್ತಿಯ ಲೈಬ್ರರಿಗಳ ಮೇಲೆ ಅವಲಂಬಿತರಾಗಿದ್ದರು. ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಮತ್ತು `for await...of` ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ಪರಿಚಯದೊಂದಿಗೆ, ನಾವು ಈಗ ಭಾಷೆಯಲ್ಲಿ ನೇರವಾಗಿ ನಿರ್ಮಿಸಲಾದ ಶಕ್ತಿಯುತ, ಸ್ಥಳೀಯ ಮತ್ತು ಅಂತರ್ಬೋಧೆಯ ಸಾಧನವನ್ನು ಹೊಂದಿದ್ದೇವೆ.
ಪುಶ್-ಆಧಾರಿತದಿಂದ ಪುಲ್-ಆಧಾರಿತ ಮಾದರಿಗೆ ಬದಲಾಯಿಸುವ ಮೂಲಕ, ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳು ಅಂತರ್ನಿರ್ಮಿತ ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಅನ್ನು ಒದಗಿಸುತ್ತವೆ. ಗ್ರಾಹಕರ ಸಂಸ್ಕರಣಾ ವೇಗವು ಸಹಜವಾಗಿ ಉತ್ಪಾದಕರ ದರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ, ಇದು ಕೋಡ್‌ಗೆ ಕಾರಣವಾಗುತ್ತದೆ:
- ಮೆಮೊರಿ ಸುರಕ್ಷಿತ: ಅನಿಯಂತ್ರಿತ ಬಫರ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ಮತ್ತು ಮೆಮೊರಿ-ಕಳೆದುಹೋದ ಕ್ರ್ಯಾಶ್‌ಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
- ಓದಬಲ್ಲದು: ಸಂಕೀರ್ಣ ಅಸಿಂಕ್ರೊನಸ್ ತರ್ಕವನ್ನು ಸರಳ, ಅನುಕ್ರಮ-ನೋಡುತ್ತಿರುವ ಲೂಪ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.
- ಸಂಯೋಜಿಸಬಲ್ಲದು: ಸೊಗಸಾದ, ಪುನರಾವರ್ತನೆ ಮಾಡಬಹುದಾದ ಡೇಟಾ ರೂಪಾಂತರ ಪೈಪ್‌ಲೈನ್‌ಗಳ ರಚನೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ.
- ದೃಢವಾದ: ಪ್ರಮಾಣಿತ `try...catch...finally` ಬ್ಲಾಕ್‌ಗಳೊಂದಿಗೆ ದೋಷ ನಿರ್ವಹಣೆ ಮತ್ತು ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
ಮುಂದಿನ ಬಾರಿ ನೀವು ಫೈಲ್, API, ಅಥವಾ ಯಾವುದೇ ಇತರ ಅಸಿಂಕ್ರೊನಸ್ ಮೂಲದಿಂದ ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಪ್ರೊಸೆಸ್ ಮಾಡಬೇಕಾದಾಗ, ಹಸ್ತಚಾಲಿತ ಬಫರಿಂಗ್ ಅಥವಾ ಸಂಕೀರ್ಣ ಕಾಲ್‌ಬ್ಯಾಕ್‌ಗಳಿಗಾಗಿ ತಲುಪಬೇಡಿ. ಅಸಿಂಕ್ ಜನರೇಟರ್‌ಗಳ ಪುಲ್-ಆಧಾರಿತ ಸೊಬಗನ್ನು ಅಳವಡಿಸಿಕೊಳ್ಳಿ. ಇದು ಆಧುನಿಕ JavaScript ಮಾದರಿಯಾಗಿದ್ದು, ಇದು ನಿಮ್ಮ ಅಸಿಂಕ್ರೊನಸ್ ಕೋಡ್ ಅನ್ನು ಸ್ವಚ್ಛ, ಸುರಕ್ಷಿತ ಮತ್ತು ಹೆಚ್ಚು ಶಕ್ತಿಯುತವಾಗಿಸುತ್ತದೆ.